home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / struct.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  4KB  |  117 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. """
  5. Functions to convert between Python values and C structs.
  6. Python strings are used to hold the data representing the C struct
  7. and also as format strings to describe the layout of data in the C struct.
  8.  
  9. The optional first format char indicates byte order, size and alignment:
  10.  @: native order, size & alignment (default)
  11.  =: native order, std. size & alignment
  12.  <: little-endian, std. size & alignment
  13.  >: big-endian, std. size & alignment
  14.  !: same as >
  15.  
  16. The remaining chars indicate types of args and must match exactly;
  17. these can be preceded by a decimal repeat count:
  18.  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  19.  h:short; H:unsigned short; i:int; I:unsigned int;
  20.  l:long; L:unsigned long; f:float; d:double.
  21. Special cases (preceding decimal count indicates length):
  22.  s:string (array of char); p: pascal string (with count byte).
  23. Special case (only available in native format):
  24.  P:an integer type that is wide enough to hold a pointer.
  25. Special case (not in native mode unless 'long long' in platform C):
  26.  q:long long; Q:unsigned long long
  27. Whitespace between formats is ignored.
  28.  
  29. The variable struct.error is an exception raised on errors.
  30. """
  31. __version__ = '0.1'
  32. from _struct import Struct, error
  33. _MAXCACHE = 100
  34. _cache = { }
  35.  
  36. def _compile(fmt):
  37.     if len(_cache) >= _MAXCACHE:
  38.         _cache.clear()
  39.     
  40.     s = Struct(fmt)
  41.     _cache[fmt] = s
  42.     return s
  43.  
  44.  
  45. def calcsize(fmt):
  46.     '''
  47.     Return size of C struct described by format string fmt.
  48.     See struct.__doc__ for more on format strings.
  49.     '''
  50.     
  51.     try:
  52.         o = _cache[fmt]
  53.     except KeyError:
  54.         o = _compile(fmt)
  55.  
  56.     return o.size
  57.  
  58.  
  59. def pack(fmt, *args):
  60.     '''
  61.     Return string containing values v1, v2, ... packed according to fmt.
  62.     See struct.__doc__ for more on format strings.
  63.     '''
  64.     
  65.     try:
  66.         o = _cache[fmt]
  67.     except KeyError:
  68.         o = _compile(fmt)
  69.  
  70.     return o.pack(*args)
  71.  
  72.  
  73. def pack_into(fmt, buf, offset, *args):
  74.     '''
  75.     Pack the values v1, v2, ... according to fmt, write
  76.     the packed bytes into the writable buffer buf starting at offset.
  77.     See struct.__doc__ for more on format strings.
  78.     '''
  79.     
  80.     try:
  81.         o = _cache[fmt]
  82.     except KeyError:
  83.         o = _compile(fmt)
  84.  
  85.     return o.pack_into(buf, offset, *args)
  86.  
  87.  
  88. def unpack(fmt, s):
  89.     '''
  90.     Unpack the string, containing packed C structure data, according
  91.     to fmt.  Requires len(string)==calcsize(fmt).
  92.     See struct.__doc__ for more on format strings.
  93.     '''
  94.     
  95.     try:
  96.         o = _cache[fmt]
  97.     except KeyError:
  98.         o = _compile(fmt)
  99.  
  100.     return o.unpack(s)
  101.  
  102.  
  103. def unpack_from(fmt, buf, offset = 0):
  104.     '''
  105.     Unpack the buffer, containing packed C structure data, according to
  106.     fmt starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt).
  107.     See struct.__doc__ for more on format strings.
  108.     '''
  109.     
  110.     try:
  111.         o = _cache[fmt]
  112.     except KeyError:
  113.         o = _compile(fmt)
  114.  
  115.     return o.unpack_from(buf, offset)
  116.  
  117.